package com.laosg.study.base.ch6

/**
  * Created by kaimin on 10/5/2019.
  * time : 10:18
  */
object FunctionLevelDemo {

  def main(args: Array[String]): Unit = {

    //需求是，1) 将集合 list 中的所有数字+1，并返回一个新的集合
   // 2) 要求忽略掉 非数字 的元素，即返回的 新的集合 形式为 (2, 3, 4, 5)
    val list = List(1,2,3,"123")
    //第一种 filter+map

    println("结果是："+println(list.filter(f1).map(f3).map(f2).foreach(println)))

    //第二种，用模式匹配

    println("-----")
    list.map(pipei).foreach(println)

    //第三种，使用偏函数
    val funx = new PartialFunction[Any,Int] {
      override def isDefinedAt(x: Any) = {
        println("做判断")
        //做判断
        x.isInstanceOf[Int]
      }

      override def apply(v1: Any) ={
        //做操作
        println("做操作")
        v1.asInstanceOf[Int]+2
      }
    }
    println("----")
    list.collect(funx).foreach(println)

    println("------")
    var xs = List(1,2.2f,"12")
    xs.collect(p2).foreach(println)

    println("------")
    println(Array(1,2,3).map(pulus).mkString(","))
    println("plus 类型："+(pulus _))

    val tri = (a:Double)=>{
      a*3
    }
    println("匿名函数；"+tri(3)+" 类型是："+tri)

    println("高阶函数"+test(sum,mo,11))

    println("匿名函数："+minusxy(3)(4))

    val xcs = List(1,2,3,4,5,6)

    println("参数类型推断1:"+xcs.map({f:Int=>f+1}))
    println("参数类型推断2:"+xcs.map({f=>f+1}))
    println("参数类型推断3:"+xcs.map(f=>f+1))
    println("参数类型推断4:"+xcs.map(_+1))
    println("参数类型推断5:"+xcs.reduce(_+_))
    val f123=minusxy(3)
    println("闭包就是变量和函数的整体："+f123(8))

    val judge = suffix(".jpg")
    println("闭包完成："+judge("123.jpg"))
    println("闭包完成："+judge("1234"))

    println("正常的乘除："+multixy(1,3))

    val mc=multixyBi(4)

    println("闭包："+mc(2))
    println("柯里化："+multiCarry(3)(4))

    println("比较两个字符串在忽略大小写的情况下是否相等："+compare("aBx")("abx"))
  }


  def compare(a:String)(b:String)=a.equalsIgnoreCase(b)


  def multiCarry(x:Int)=(y:Int)=>x*y
  /**
    *
    * @param y
    * @return
    */
  def multixyBi(y:Int) ={
    (x:Int)=>x*y
  }

  def multixy(x:Int,y:Int)={
    x*y
  }

//  比如 文件名 是 dog =>dog.jpg
//  比如 文件名 是 cat.jpg => cat.jpg
  def suffix(ss:String)={
  (fileName:String)=>{
    if (fileName.endsWith(ss)) {
      fileName
    }else{
      fileName+ss
    }
  }
}

  def minusxy(x:Int)={
    (y:Int)=>x-y//这就是一个匿名函数
  }
  /**
    * 定义的高阶函数
    * @param f1
    * @param f2
    * @param n1
    * @return
    */
  def test(f1:Double=>Double,f2:Double=>Int,n1:Double)={
    f1(f2(n1))
  }
  def sum(d:Double):Double = {
      d+d
  }
  def mo(d:Double):Int={
    d.toInt%2
  }

  def p2:PartialFunction[Any,Int]={
    case i:Int=>i+1
    case j:Double=>(j+8).toInt
    case k:Float=>(k-6).toInt
  }

  def pulus(x:Int)=x+3


  def pipei(i:Any):Any={
    i match {
      case i:Int=>i+1
      case _=>
    }
  }

  /**
    * 定义是否是Int类型
    * @param n
    * @return
    */
  def f1(n:Any):Boolean={
    n.isInstanceOf[Int]
  }

  /**
    * 定义+1
    * @param n
    * @return
    */
  def f2(n:Int):Int={
    n+1
  }

  /**
    * 将类型转换成int
    *
    * @param n
    * @return
    */
  def f3(n:Any):Int={
    n.asInstanceOf[Int]
  }



}
